/*******************************************************************************
* Copyright (c) 2005, 2013 Richard Hoefter and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Richard Hoefter (richard.hoefter@web.de) - initial API and implementation, bug 313386
* IBM Corporation - incorporating into Eclipse
*******************************************************************************/
package org.eclipse.ant.internal.ui.datatransfer;
import java.io.File;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import org.eclipse.core.resources.IFile;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.ToolFactory;
import org.eclipse.jdt.core.util.IClassFileReader;
import org.eclipse.jdt.core.util.IConstantPool;
import org.eclipse.jdt.core.util.IConstantPoolConstant;
import org.eclipse.jdt.core.util.IConstantPoolEntry;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
/**
* Provides a method to analyze sources if it is possible to export projects to an Ant buildfile which compiles correctly.
*/
public class SourceAnalyzer {
/**
* Utility class.
*/
private SourceAnalyzer() {
}
/**
* Check if source directories of project has cycles or if there are dependencies between them that are not conform with classpath order.
*
* <p>
* NOTE: Unused references in classes are not considered if they cause cycles or classpath order problems. This is because this class analyzes the
* bytecode and indeed the compiler throws unused references away.
*/
public static void checkCycles(IJavaProject currentProject, EclipseClasspath classpath, Shell shell) {
StringBuffer message = new StringBuffer();
Map<String, String> src2dir = new TreeMap<>(); // map string to string
Map<String, Set<String>> srcdir2classes = new TreeMap<>(); // map string to Set of strings
determineSources(currentProject, classpath, src2dir, srcdir2classes);
Map<String, Set<String>> srcdir2sourcedirs = determineRequiredSrcDirs(src2dir, srcdir2classes);
String projectName = currentProject.getProject().getName();
List<String> cycle = new ArrayList<>();
if (isCyclic(srcdir2sourcedirs, cycle)) {
showCycleWarning(projectName, shell, cycle, message);
return;
}
checkBuildOrder(classpath, projectName, shell, srcdir2sourcedirs);
}
/**
* Determine all sources belonging to a source directory.
*/
private static void determineSources(IJavaProject currentProject, EclipseClasspath classpath, Map<String, String> src2dir, Map<String, Set<String>> srcdir2classes) {
for (int i = 0; i < classpath.srcDirs.size(); i++) {
String srcDir = classpath.srcDirs.get(i);
String classDir = classpath.classDirs.get(i);
if (EclipseClasspath.isReference(srcDir)) {
continue;
}
File dir;
if (srcDir.equals(".")) { //$NON-NLS-1$
dir = currentProject.getResource().getLocation().toFile();
} else {
IFile file = currentProject.getProject().getFile(srcDir);
dir = file.getLocation().toFile();
}
if (EclipseClasspath.isLinkedResource(srcDir)) {
String link = classpath.resolveLinkedResource(srcDir);
dir = new File(link);
if (!dir.isAbsolute()) {
// make absolute
dir = new File(ExportUtil.getProjectRoot(currentProject), link);
}
}
Set<String> sources = findFiles(dir, ".java"); //$NON-NLS-1$
// find all required classfiles for each source directory
for (Iterator<String> iter = sources.iterator(); iter.hasNext();) {
String srcFile = iter.next();
src2dir.put(srcFile, srcDir);
IFile classFile = currentProject.getProject().getFile(classDir + '/' + srcFile + ".class"); //$NON-NLS-1$
if (!classFile.exists()) {
// project was not compiled, check not possible
continue;
}
Set<String> classes = srcdir2classes.get(srcDir);
if (classes == null) {
classes = new TreeSet<>();
}
classes.addAll(getRequiredClasses(classFile));
srcdir2classes.put(srcDir, classes);
}
}
}
/**
* Determine for each source directory which other source directories it requires.
*
* @return Map string to Set of strings. (Maps source dir to Set of required source dirs.)
*/
private static Map<String, Set<String>> determineRequiredSrcDirs(Map<String, String> src2dir, Map<String, Set<String>> srcdir2classes) {
Map<String, Set<String>> srcdir2sourcedirs = new TreeMap<>(); // map string to Set of strings
for (Iterator<String> iter = srcdir2classes.keySet().iterator(); iter.hasNext();) {
String srcDir = iter.next();
Set<String> classes = srcdir2classes.get(srcDir);
for (Iterator<String> iterator = classes.iterator(); iterator.hasNext();) {
String classname = iterator.next();
String classsrc = src2dir.get(classname);
// don't add reference to itself
if (classsrc != null && !classsrc.equals(srcDir)) {
Set<String> sourcedirs = srcdir2sourcedirs.get(srcDir);
if (sourcedirs == null) {
sourcedirs = new TreeSet<>();
}
sourcedirs.add(classsrc);
srcdir2sourcedirs.put(srcDir, sourcedirs);
}
}
}
return srcdir2sourcedirs;
}
private static void showCycleWarning(String projectName, Shell shell, List<String> cycle, StringBuffer message) {
String m = MessageFormat.format(DataTransferMessages.SourceAnalyzer_0, new Object[] { projectName });
message.append(m);
message.append(ExportUtil.NEWLINE);
// print cycle path
for (String s : cycle) {
s = EclipseClasspath.getLinkedResourceName(s);
message.append(s);
message.append(" -> "); //$NON-NLS-1$
}
message.append(EclipseClasspath.getLinkedResourceName(cycle.get(0)));
MessageDialog.openWarning(shell, DataTransferMessages.SourceAnalyzer_1, message.toString());
}
/**
* Check if build order is correct.
*/
private static void checkBuildOrder(EclipseClasspath classpath, String projectName, Shell shell, Map<String, Set<String>> srcdir2sourcedirs) {
for (Iterator<String> iter = srcdir2sourcedirs.keySet().iterator(); iter.hasNext();) {
String srcdir = iter.next();
Set<String> sourcedirs = srcdir2sourcedirs.get(srcdir);
int classpathIndex = classpath.srcDirs.indexOf(srcdir);
for (Iterator<String> iterator = sourcedirs.iterator(); iterator.hasNext();) {
String requiredSrc = iterator.next();
int i = classpath.srcDirs.indexOf(requiredSrc);
if (i > classpathIndex) {
String s = MessageFormat.format(DataTransferMessages.SourceAnalyzer_3, new Object[] { projectName });
MessageDialog.openWarning(shell, DataTransferMessages.SourceAnalyzer_2, s + ExportUtil.NEWLINE + requiredSrc + " <-> " + srcdir //$NON-NLS-1$
+ ExportUtil.NEWLINE);
break;
}
}
}
}
/**
* Find all classes that are required by given class file.
*
* @param file
* a ".class" file
* @return set of strings, each contains a full qualified class name (forward slash as package separator)
*/
public static Set<String> getRequiredClasses(IFile file) {
Set<String> classes = new TreeSet<>();
IClassFile classFile = JavaCore.createClassFileFrom(file);
IClassFileReader reader = ToolFactory.createDefaultClassFileReader(classFile, IClassFileReader.CONSTANT_POOL);
if (reader == null) {
// class not compiled
return classes;
}
IConstantPool pool = reader.getConstantPool();
for (int i = 0; i < pool.getConstantPoolCount(); i++) {
if (pool.getEntryKind(i) == IConstantPoolConstant.CONSTANT_Class) {
IConstantPoolEntry entry = pool.decodeEntry(i);
String classname = new String(entry.getClassInfoName());
// don't return inner classes
int index = classname.indexOf('$');
if (index != -1) {
classname = classname.substring(0, index);
}
classes.add(classname);
}
}
return classes;
}
/**
* Find all files with particular extension under given directory.
*
* @param dir
* directory to start search
* @param extension
* extension to search
* @return filenames relative to directory (without extension and with forward slashes)
*/
public static Set<String> findFiles(File dir, String extension) {
Set<String> visited = new TreeSet<>();
findFiles(dir, dir, extension, visited);
return visited;
}
private static void findFiles(File base, File dir, String extension, Set<String> visited) {
if (dir.isDirectory()) {
File[] children = dir.listFiles();
for (int i = 0; i < children.length; i++) {
findFiles(base, children[i], extension, visited);
}
} else if (dir.getAbsolutePath().endsWith(extension)) {
// remove base directory
String filename = ExportUtil.removePrefixAndSuffix(dir.getAbsolutePath(), base.getAbsolutePath() + File.separator, extension);
visited.add(filename.replace('\\', '/'));
}
}
/**
* Check if given graph that is described through a map is cyclic.
*
* @param srcdir2sourcedirs
* Maps string to set of strings. The keys are the graph nodes which are mapped to its neighbors.
* @param cycle
* filled with name of nodes which cause cycle
*/
private static boolean isCyclic(Map<String, Set<String>> srcdir2sourcedirs, List<String> cycle) {
return !isAcyclic(srcdir2sourcedirs, cycle);
}
private static boolean isAcyclic(Map<String, Set<String>> srcdir2sourcedirs, List<String> cycle) {
// standard graph theory
List<String> visited = new ArrayList<>();
List<String> exited = new ArrayList<>();
for (Iterator<String> iter = srcdir2sourcedirs.keySet().iterator(); iter.hasNext();) {
String srcdir = iter.next();
if (!visited.contains(srcdir)) {
if (circleSearch(srcdir, srcdir2sourcedirs, visited, exited, cycle)) {
return false;
}
}
}
return true;
}
private static boolean circleSearch(String srcdir, Map<String, Set<String>> srcdir2sourcedirs, List<String> visited, List<String> exited, List<String> cycle) {
boolean res = false;
visited.add(srcdir);
cycle.add(srcdir);
Set<String> sourcedirs = srcdir2sourcedirs.get(srcdir);
if (sourcedirs != null) {
for (Iterator<String> iter = sourcedirs.iterator(); iter.hasNext();) {
String src = iter.next();
if (!visited.contains(src)) {
res = circleSearch(src, srcdir2sourcedirs, visited, exited, cycle);
} else if (!exited.contains(src)) {
res = true;
}
if (res) {
break;
}
}
}
if (!res) {
cycle.clear();
}
exited.add(srcdir);
return res;
}
}